/*********************************************************************************************************************
 * COPYRIGHT NOTICE
 * Copyright (c) 2018,逐飞科技
 * All rights reserved.
 * 技术讨论QQ群：	一群：179029047(已满)
 *					二群：244861897(已满)
 *					三群：824575535
 *
 * 以下所有内容版权均属逐飞科技所有，未经允许不得用于商业用途，
 * 欢迎各位使用并传播本程序，修改内容时必须保留逐飞科技的版权声明。
 *
 * @file			zf_isr.c
 * @company			成都逐飞科技有限公司
 * @author			逐飞科技(QQ3184284598)
 * @version			查看doc内version文件 版本说明
 * @Software		IAR 8.3 or MDK 5.24
 * @Taobao			https://seekfree.taobao.com/
 * @date			2020-03-25
 * @note			本文件作为 LPC55S 系列芯片开源库外设文件
					提供中断处理
 ********************************************************************************************************************/
#include "zf_isr.h"

#define zf_utick_irq_handler		UTICK0_IRQHandler													// FlexCOMM 0 IOT定义中断服务函数
extern void UTICK0_DriverIRQHandler (void);
void (*zf_utick_irq_func)(void);

// UTICK 中断处理分支
void zf_utick_irq_handler(void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(zf_utick_irq_func != NULL)
		zf_utick_irq_func();																			// 调用用户中断处理函数
	else
		UTICK0_DriverIRQHandler();																		// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

#define flexcomm0_irqhandler			FLEXCOMM0_IRQHandler											// FlexCOMM 0 IOT定义中断服务函数
#define flexcomm1_irqhandler			FLEXCOMM1_IRQHandler											// FlexCOMM 1 IOT定义中断服务函数
#define flexcomm2_irqhandler			FLEXCOMM2_IRQHandler											// FlexCOMM 2 IOT定义中断服务函数
#define flexcomm3_irqhandler			FLEXCOMM3_IRQHandler											// FlexCOMM 3 IOT定义中断服务函数
#define flexcomm4_irqhandler			FLEXCOMM4_IRQHandler											// FlexCOMM 4 IOT定义中断服务函数
#define flexcomm5_irqhandler			FLEXCOMM5_IRQHandler											// FlexCOMM 5 IOT定义中断服务函数
#define flexcomm6_irqhandler			FLEXCOMM6_IRQHandler											// FlexCOMM 6 IOT定义中断服务函数
#define flexcomm7_irqhandler			FLEXCOMM7_IRQHandler											// FlexCOMM 7 IOT定义中断服务函数

#define hspi_irqhandler					FLEXCOMM8_IRQHandler											// HSPI IOT定义中断服务函数

extern void FLEXCOMM0_DriverIRQHandler (void);															// FlexCOMM 0 SDK定义中断服务函数
extern void FLEXCOMM1_DriverIRQHandler (void);															// FlexCOMM 1 SDK定义中断服务函数
extern void FLEXCOMM2_DriverIRQHandler (void);															// FlexCOMM 2 SDK定义中断服务函数
extern void FLEXCOMM3_DriverIRQHandler (void);															// FlexCOMM 3 SDK定义中断服务函数
extern void FLEXCOMM4_DriverIRQHandler (void);															// FlexCOMM 4 SDK定义中断服务函数
extern void FLEXCOMM5_DriverIRQHandler (void);															// FlexCOMM 5 SDK定义中断服务函数
extern void FLEXCOMM6_DriverIRQHandler (void);															// FlexCOMM 6 SDK定义中断服务函数
extern void FLEXCOMM7_DriverIRQHandler (void);															// FlexCOMM 7 SDK定义中断服务函数

extern void FLEXCOMM8_DriverIRQHandler (void);															// FlexCOMM 8 SDK定义中断服务函数

void (*flexcomm_irqn_func[8])(void);																	// 中断函数指针数组
IRQn_Type flexcomm_irqn[8] = {	FLEXCOMM0_IRQn, FLEXCOMM1_IRQn, FLEXCOMM2_IRQn, FLEXCOMM3_IRQn,			// FlexCOMM 中断配置对象
								FLEXCOMM4_IRQn, FLEXCOMM5_IRQn, FLEXCOMM6_IRQn, FLEXCOMM7_IRQn};

void (*hspi_irqn_func)(void);
//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 0 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm0_irqhandler  (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[0] != NULL)
		flexcomm_irqn_func[0]();																		// 调用用户中断处理函数
	else
		FLEXCOMM0_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 1 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm1_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[1] != NULL)
		flexcomm_irqn_func[1]();																		// 调用用户中断处理函数
	else
		FLEXCOMM1_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 2 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm2_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[2] != NULL)
		flexcomm_irqn_func[2]();																		// 调用用户中断处理函数
	else
		FLEXCOMM2_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 3 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm3_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[3] != NULL)
		flexcomm_irqn_func[3]();																		// 调用用户中断处理函数
	else
		FLEXCOMM3_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 4 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm4_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[4] != NULL)
		flexcomm_irqn_func[4]();																		// 调用用户中断处理函数
	else
		FLEXCOMM4_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 5 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm5_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[5] != NULL)
		flexcomm_irqn_func[5]();																		// 调用用户中断处理函数
	else
		FLEXCOMM5_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 6 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm6_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[6] != NULL)
		flexcomm_irqn_func[6]();																		// 调用用户中断处理函数
	else
		FLEXCOMM6_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

//-------------------------------------------------------------------------------------------------------------------
//	@brief		FlexCOMM 7 的中断服务函数
//-------------------------------------------------------------------------------------------------------------------
void flexcomm7_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(flexcomm_irqn_func[7] != NULL)
		flexcomm_irqn_func[7]();																		// 调用用户中断处理函数
	else
		FLEXCOMM7_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void hspi_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif

	if(hspi_irqn_func != NULL)
		hspi_irqn_func();																				// 调用用户中断处理函数
	else
		FLEXCOMM8_DriverIRQHandler();																	// 库原有中断服务函数

#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

#define pint0_irqhandler			PIN_INT0_IRQHandler													// PINT 0 IOT定义中断服务函数
#define pint1_irqhandler			PIN_INT1_IRQHandler													// PINT 1 IOT定义中断服务函数
#define pint2_irqhandler			PIN_INT2_IRQHandler													// PINT 2 IOT定义中断服务函数
#define pint3_irqhandler			PIN_INT3_IRQHandler													// PINT 3 IOT定义中断服务函数
#define pint4_irqhandler			PIN_INT4_IRQHandler													// PINT 4 IOT定义中断服务函数
#define pint5_irqhandler			PIN_INT5_IRQHandler													// PINT 5 IOT定义中断服务函数
#define pint6_irqhandler			PIN_INT6_IRQHandler													// PINT 6 IOT定义中断服务函数
#define pint7_irqhandler			PIN_INT7_IRQHandler													// PINT 7 IOT定义中断服务函数

#define gint0_irqhandler			GINT0_IRQHandler													// GINT 0 IOT定义中断服务函数
#define gint1_irqhandler			GINT1_IRQHandler													// GINT 1 IOT定义中断服务函数

extern void PIN_INT0_DriverIRQHandler (void);															// PINT 0 SDK定义中断服务函数
extern void PIN_INT1_DriverIRQHandler (void);															// PINT 1 SDK定义中断服务函数
extern void PIN_INT2_DriverIRQHandler (void);															// PINT 2 SDK定义中断服务函数
extern void PIN_INT3_DriverIRQHandler (void);															// PINT 3 SDK定义中断服务函数
extern void PIN_INT4_DriverIRQHandler (void);															// PINT 4 SDK定义中断服务函数
extern void PIN_INT5_DriverIRQHandler (void);															// PINT 5 SDK定义中断服务函数
extern void PIN_INT6_DriverIRQHandler (void);															// PINT 6 SDK定义中断服务函数
extern void PIN_INT7_DriverIRQHandler (void);															// PINT 7 SDK定义中断服务函数

extern void GINT0_DriverIRQHandler (void);																// GINT 0 SDK定义中断服务函数
extern void GINT1_DriverIRQHandler (void);																// GINT 1 SDK定义中断服务函数

void (*pint_irqn_func[8])(void);																		// 中断函数指针数组
void (*gint_irqn_func[2])(void);																		// 中断函数指针数组

void pint0_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[0] != NULL)
		pint_irqn_func[0]();																			// 调用用户中断处理函数
	else
		PIN_INT0_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x1U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 0);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint1_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[1] != NULL)
		pint_irqn_func[1]();																			// 调用用户中断处理函数
	else
		PIN_INT1_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x2U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 1);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint2_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[2] != NULL)
		pint_irqn_func[2]();																			// 调用用户中断处理函数
	else
		PIN_INT2_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x4U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 2);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint3_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[3] != NULL)
		pint_irqn_func[3]();																			// 调用用户中断处理函数
	else
		PIN_INT3_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x8U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 3);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint4_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[4] != NULL)
		pint_irqn_func[4]();																			// 调用用户中断处理函数
	else
		PIN_INT4_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x10U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 4);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint5_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[5] != NULL)
		pint_irqn_func[5]();																			// 调用用户中断处理函数
	else
		PIN_INT5_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x20U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 5);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint6_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[6] != NULL)
		pint_irqn_func[6]();																			// 调用用户中断处理函数
	else
		PIN_INT6_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x40U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 6);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void pint7_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	if(pint_irqn_func[7] != NULL)
		pint_irqn_func[7]();																			// 调用用户中断处理函数
	else
		PIN_INT7_DriverIRQHandler();																	// 库原有中断服务函数

	if ((PINT->ISEL & 0x80U) == 0x0U)
	{
		/* Edge sensitive: clear Pin interrupt after callback */
		PINT_PinInterruptClrStatus(PINT, 7);
	}
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void gint0_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	GINT0->CTRL |= GINT_CTRL_INT_MASK;																	// 清除中断标志

	if(gint_irqn_func[0] != NULL)
		gint_irqn_func[0]();																			// 调用用户中断处理函数
	else
		GINT0_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void gint1_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	GINT1->CTRL |= GINT_CTRL_INT_MASK;																	// 清除中断标志

	if(gint_irqn_func[1] != NULL)
		gint_irqn_func[1]();																			// 调用用户中断处理函数
	else
		GINT1_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

#define ctimer0_irqhandler			CTIMER0_IRQHandler
#define ctimer1_irqhandler			CTIMER1_IRQHandler
#define ctimer2_irqhandler			CTIMER2_IRQHandler
#define ctimer3_irqhandler			CTIMER3_IRQHandler
#define ctimer4_irqhandler			CTIMER4_IRQHandler

extern void CTIMER0_DriverIRQHandler (void);
extern void CTIMER1_DriverIRQHandler (void);
extern void CTIMER2_DriverIRQHandler (void);
extern void CTIMER3_DriverIRQHandler (void);
extern void CTIMER4_DriverIRQHandler (void);

extern uint8_t zf_ctimer_pwmfreq_ch[5];

void (*ctimer_irqn_func[5])(void);

void ctimer0_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	CTIMER0->IR |= (0x00000001 << zf_ctimer_pwmfreq_ch[0]);												// 清除中断标志

	if(ctimer_irqn_func[0] != NULL)
		ctimer_irqn_func[0]();																			// 调用用户中断处理函数
	else
		CTIMER0_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void ctimer1_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	CTIMER1->IR |= (0x00000001 << zf_ctimer_pwmfreq_ch[1]);												// 清除中断标志

	if(ctimer_irqn_func[1] != NULL)
		ctimer_irqn_func[1]();																			// 调用用户中断处理函数
	else
		CTIMER1_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void ctimer2_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	CTIMER2->IR |= (0x00000001 << zf_ctimer_pwmfreq_ch[2]);												// 清除中断标志

	if(ctimer_irqn_func[2] != NULL)
		ctimer_irqn_func[2]();																			// 调用用户中断处理函数
	else
		CTIMER2_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void ctimer3_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	CTIMER3->IR |= (0x00000001 << zf_ctimer_pwmfreq_ch[3]);												// 清除中断标志

	if(ctimer_irqn_func[3] != NULL)
		ctimer_irqn_func[3]();																			// 调用用户中断处理函数
	else
		CTIMER3_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}

void ctimer4_irqhandler (void)
{
#ifdef RT_THREAD
	/* enter interrupt */
	rt_interrupt_enter();
#endif
	CTIMER4->IR |= (0x00000001 << zf_ctimer_pwmfreq_ch[4]);												// 清除中断标志

	if(ctimer_irqn_func[4] != NULL)
		ctimer_irqn_func[4]();																			// 调用用户中断处理函数
	else
		CTIMER4_DriverIRQHandler();																		// 库原有中断服务函数
#ifdef RT_THREAD
	/* leave interrupt */
	rt_interrupt_leave();
#endif
}
